home *** CD-ROM | disk | FTP | other *** search
/ Celestin Apprentice 7 / Apprentice-Release7.iso / Source Code / Pascal / Snippets / PNL Libraries / TCPTypes.p < prev    next >
Encoding:
Text File  |  1997-04-01  |  14.6 KB  |  646 lines  |  [TEXT/CWIE]
  1. unit TCPTypes;
  2.  
  3. { TCPTypes © Peter Lewis, Oct 1991 }
  4. { This source is Freeware }
  5.  
  6. interface
  7.  
  8.     uses
  9.         Types, OSUtils;
  10.  
  11. {$PUSH}
  12. {$ALIGN MAC68K}
  13.  
  14. { MacTCP return Codes in the range -23000 through -23049 }
  15.     const
  16.         ipBadLapErr = -23000;                    { bad network configuration }
  17.         ipBadCnfgErr = -23001;                { bad IP configuration error }
  18.         ipNoCnfgErr = -23002;                    { missing IP or LAP configuration error }
  19.         ipLoadErr = -23003;                    { error in MacTCP load }
  20.         ipBadAddrErr = -23004;                    { error in getting address }
  21.         connectionClosingErr = -23005;            { connection is closing }
  22.         invalidLengthErr = -23006;
  23.         connectionExistsErr = -23007;            { request conflicts with existing connection }
  24.         connectionDoesntExistErr = -23008;        { connection does not exist }
  25.         insufficientResourcesErr = -23009;        { insufficient resources to perform request }
  26.         invalidStreamPtrErr = -23010;
  27.         streamAlreadyOpenErr = -23011;
  28.         connectionTerminatedErr = -23012;
  29.         invalidBufPtrErr = -23013;
  30.         invalidRDSErr = -23014;
  31.         invalidWDSErr = -23014;
  32.         openFailedErr = -23015;
  33.         commandTimeoutErr = -23016;
  34.         duplicateSocketErr = -23017;
  35.  
  36. { Error codes from internal IP functions }
  37.         ipDontFragErr = -23032;                { Packet too large to send w/o fragmenting }
  38.         ipDestDeadErr = -23033;                { destination not responding }
  39.         icmpEchoTimeoutErr = -23035;        { ICMP echo timed-out }
  40.         ipNoFragMemErr = -23036;            { no memory to send fragmented pkt }
  41.         ipRouteErr = -23037;                    { can't route packet off-net }
  42.  
  43.         nameSyntaxErr = -23041;
  44.         cacheFaultErr = -23042;
  45.         noResultProcErr = -23043;
  46.         noNameServerErr = -23044;
  47.         authNameErrErr = -23045;
  48.         noAnsErr = -23046;
  49.         dnrErr = -23047;
  50.         outOfMemoryErr = -23048;
  51.  
  52. { connectionState }
  53.     const
  54.         CState_Closed = 0;
  55.         CState_Listening = 2;
  56.         CState_Opening1 = 4;
  57.         CState_Opening2 = 6;
  58.         CState_Established = 8;
  59.         CState_Closing1 = 10;
  60.         CState_Closing2 = 12;
  61.         CState_Closing3 = 16;
  62.         CState_Closing4 = 18;
  63.         CState_Closing5 = 20;
  64.         CState_PleaseClose = 14;
  65.  
  66.     type
  67.         AddrClasses = integer;
  68.     const
  69.         AC_A = 1;
  70.         AC_NS = 2;
  71.         AC_CNAME = 5;
  72.         AC_HINFO = 13;
  73.         AC_MX = 15;
  74.  
  75.     const
  76.         CTRUE = $FF;
  77.         CFALSE = $00;
  78.  
  79.     type
  80.         C_BOOLEAN = SignedByte;
  81.         CSTRING = Ptr;
  82.         CStr30 = packed array[0..29] of char;
  83.         CStr255 = packed array[0..255] of char;
  84.         ipAddr = unsignedlong;
  85.         ipAddrArray = array[1..1000] of ipAddr;
  86.         ipAddrArrayPtr = ^ipAddrArray;
  87.         ipPort = unsignedword;
  88.         StreamPtr = Ptr;
  89.  
  90.     type
  91.         wdsType = record            { Write block for TCP driver. }
  92.                 size: UInt16;                { Number of bytes. }
  93.                 buffer: Ptr;                { Pointer to bytes. }
  94.                 term: UInt16;                { Zero for end of blocks. }
  95.             end;
  96.         wdsPtr = ^wdsType;
  97.         wdsEntry = record
  98.                 size: UInt16;                { Number of bytes. }
  99.                 buffer: Ptr;                { Pointer to bytes. }
  100.             end;
  101.  
  102.     type
  103.         HInfoRec = record
  104.                 cpuType: CStr30;
  105.                 osType: CStr30;
  106.             end;
  107.  
  108.     type
  109.         MXRec = record
  110.                 preference: integer; { unsigned! }
  111.                 exchange: CStr255;
  112.             end;
  113.  
  114.     type
  115.         hostInfo = record
  116.                 rtnCode: longint;
  117.                 rtnHostName: CStr255;
  118.                 case integer of
  119.                     1: (
  120.                             addrs: array[1..4] of ipAddr;
  121.                     );
  122.                     2: (
  123.                             hinfo: HInfoRec;
  124.                     );
  125.                     3: (
  126.                             mx: MXRec;
  127.                     );
  128.             end;
  129.         hostInfoPtr = ^hostInfo;
  130. {
  131.         hostInfo = record
  132.                 rtnCode: longint;
  133.                 rtnHostName: Str255;
  134.                 addrs: array[1..4] of ipAddr;
  135.             end;
  136.         hostInfoPtr = ^hostInfo;
  137. }
  138.  
  139.     type
  140.         cacheEntryRecord = record
  141.                 cname: CSTRING;
  142.                 typ: integer;
  143.                 class: integer;
  144.                 ttl: longint;
  145.                 case integer of
  146.                     1: (
  147.                             name: CSTRING;
  148.                     );
  149.                     2: (
  150.                             addr: ipAddr;
  151.                     );
  152.             end;
  153.         cacheEntryRecordPtr = ^cacheEntryRecord;
  154.  
  155.     const { csCodes for the TCP driver: }
  156.         TCPcsGetMyIP = 15;
  157.         TCPcsEchoICMP = 17;
  158.         TCPcsLAPStats = 19;
  159.         TCPcsCreate = 30;
  160.         TCPcsPassiveOpen = 31;
  161.         TCPcsActiveOpen = 32;
  162. {    TCPcsActOpenWithData = 33;}
  163.         TCPcsSend = 34;
  164.         TCPcsNoCopyRcv = 35;
  165.         TCPcsRcvBfrReturn = 36;
  166.         TCPcsRcv = 37;
  167.         TCPcsClose = 38;
  168.         TCPcsAbort = 39;
  169.         TCPcsStatus = 40;
  170.         TCPcsExtendedStat = 41;
  171.         TCPcsRelease = 42;
  172.         TCPcsGlobalInfo = 43;
  173.  
  174.         UDPcsCreate = 20;
  175.         UDPcsRead = 21;
  176.         UDPcsBfrReturn = 22;
  177.         UDPcsWrite = 23;
  178.         UDPcsRelease = 24;
  179.         UDPcsMaxMTUSize = 25;
  180.         UDPcsStatus = 26;
  181.         UDPcsMultiCreate = 27;
  182.         UDPcsMultiSend = 28;
  183.         UDPcsMultiRead = 29;
  184.  
  185.     type
  186.         TCPEventCode = integer;
  187.     const
  188.         TEC_Closing = 1;
  189.         TEC_ULPTimeout = 2;
  190.         TEC_Terminate = 3;
  191.         TEC_DataArrival = 4;
  192.         TEC_Urgent = 5;
  193.         TEC_ICMPReceived = 6;
  194.         TEC_last = 32767;
  195.  
  196.     type
  197.         UDPEventCode = integer;
  198.     const
  199.         UDPDataArrival = 1;
  200.         UDPICMPReceived = 2;
  201.         lastUDPEvent = 32767;
  202.  
  203.     type
  204.         TCPTerminateReason = integer;
  205.     const {TCPTerminateReasons: }
  206.         TTR_RemoteAbort = 2;
  207.         TTR_NetworkFailure = 3;
  208.         TTR_SecPrecMismatch = 4;
  209.         TTR_ULPTimeoutTerminate = 5;
  210.         TTR_ULPAbort = 6;
  211.         TTR_ULPClose = 7;
  212.         TTR_ServiceError = 8;
  213.         TTR_last = 32767;
  214.  
  215.     type
  216.         ICMPMsgType = integer;
  217.     const
  218.         ICMP_NetUnreach = 0;
  219.         ICMP_HostUnreach = 1;
  220.         ICMP_ProtocolUnreach = 2;
  221.         ICMP_PortUnreach = 3;
  222.         ICMP_FragReqd = 4;
  223.         ICMP_SourceRouteFailed = 5;
  224.         ICMP_TimeExceeded = 6;
  225.         ICMP_ParmProblem = 7;
  226.         ICMP_MissingOption = 8;
  227.  
  228.     type
  229.         TCPNotifyProc = ProcPtr;
  230. { procedure TCPNotifyProc(tcpStream:StreamPtr; event:TCPEventCode; userDataPtr:Ptr; }
  231. {                                   terminReason:TCPTerminateReason; icmpMsg:ICMPReportPtr); }
  232.  
  233.     type
  234.         TCPIOCompletionProc = ProcPtr;
  235. { C procedure TCPIOCompletionProc(iopb:TCPControlBlockPtr); - WHY IS THIS A C PROC???? }
  236.  
  237.     type
  238.         UDPNotifyProc = ProcPtr;
  239. { procedure UDPProc(udpStream:StreamPtr ; eventCode:integer;userDataPtr:Ptr; icmpMsg:ICMPReportPtr) }
  240.  
  241.     type
  242.         UDPIOCompletionProc = ProcPtr;
  243. { C procedure UDPIOCompletionProc(iopb:UDPiopb Ptr) }
  244.  
  245.     type
  246.         ICMPEchoNotifyProc = ProcPtr;
  247. { C procedure ICMPEchoNotifyProc(iopb:IPControlBlockPtr) }
  248. { WARNING: Ignore the docs, its a C proceudre no matter what they say }
  249.  
  250.     type
  251.         ICMPReport = record
  252.                 stream: StreamPtr;
  253.                 localhost: ipAddr;
  254.                 localport: ipPort;
  255.                 remotehost: ipAddr;
  256.                 remoteport: ipPort;
  257.                 reporttype: ICMPMsgType;
  258.                 optionalAddlInfo: integer;
  259.                 optionalAddlInfoPtr: Ptr;
  260.             end;
  261.  
  262.     const
  263.         NBP_TABLE_SIZE = 20;            { number of NBP table entries }
  264.         NBP_MAX_NAME_SIZE = 16 + 10 + 2;
  265.         ARP_TABLE_SIZE = 20;            { number of ARP table entries }
  266.  
  267.     type
  268.         nbpEntry = record
  269.                 ip_address: ipAddr;                { IP address }
  270.                 at_address: longint;                { matching AppleTalk address }
  271.                 gateway: Boolean;                { TRUE if entry for a gateway }
  272.                 valid: Boolean;                    { TRUE if LAP address is valid }
  273.                 probing: Boolean;                { TRUE if NBP lookup pending }
  274.                 age: integer;                    { ticks since cache entry verified }
  275.                 access: integer;                    { ticks since last access }
  276.                 filler: packed array[1..116] of Byte;            { for internal use only !!! }
  277.             end;
  278.         EnetAddr = record
  279.                 en_hi: integer;
  280.                 en_lo: longint;
  281.             end;
  282.         arpEntry = record
  283.                 age: integer;            { cache aging field }
  284.                 protocol: integer;        { Protocol type }
  285.                 ip_address: ipAddr;        { IP address }
  286.                 en_address: EnetAddr;        { matching Ethernet address }
  287.             end;
  288.         AddrXlation = record
  289.                 case integer of
  290.                     0: (
  291.                             arp_table: ^arpEntry
  292.                     );
  293.                     1: (
  294.                             nbp_entry: ^nbpEntry
  295.                     )
  296.             end;
  297.         LAPStats = record
  298.                 ifType: integer;
  299.                 ifString: CSTRING;
  300.                 ifMaxMTU: integer;
  301.                 ifSpeed: longint;
  302.                 ifPhyAddrLength: integer;
  303.                 ifPhysicalAddress: CSTRING;
  304.                 addr: AddrXlation;
  305.                 slotNumber: integer;
  306.             end;
  307.         IPEchoPB = record
  308.                 dest: ipAddr;                { echo to IP address }
  309.                 data: wdsEntry;
  310.                 timeout: integer;
  311.                 options: Ptr;
  312.                 optlength: integer;
  313.                 icmpCompletion: ICMPEchoNotifyProc;
  314.                 userDataPtr: Ptr;
  315.             end;
  316.         LAPStatsPB = record
  317.                 lapStatsPtr: ^LAPStats;
  318.             end;
  319.         ICMPEchoInfo = record
  320.                 params: array[1..11] of integer;
  321.                 echoRequestOut: longint;    { time in ticks of when the echo request went out }
  322.                 echoReplyIn: longint;        { time in ticks of when the reply was received }
  323.                 data: wdsEntry;        { data received in responce }
  324.                 options: Ptr;
  325.                 userDataPtr: Ptr;
  326.             end;
  327.         IPGetMyIPPB = record
  328.                 ourAddress: ipAddr;            { our IP address }
  329.                 ourNetMask: ipAddr;            { our IP net mask }
  330.             end;
  331.  
  332.         IPControlBlock = record
  333.                 qLink: QElemPtr;
  334.                 qType: INTEGER;
  335.                 ioTrap: INTEGER;
  336.                 ioCmdAddr: Ptr;
  337.                 ioCompletion: TCPIOCompletionProc; {completion routine, or NIL if none}
  338.                 ioResult: OSErr; {result code}
  339.                 ioNamePtr: StringPtr;
  340.                 ioVRefNum: INTEGER;
  341.                 ioCRefNum: INTEGER; {device refnum}
  342.                 case csCode : integer of
  343.                     TCPcsGetMyIP: (
  344.                             getmyip: IPGetMyIPPB;
  345.                     );
  346.                     TCPcsEchoICMP: (
  347.                             echo: IPEchoPB
  348.                     );
  349.                     9999: (
  350.                             echoinfo: ICMPEchoInfo
  351.                     );
  352.                     TCPcsLAPStats: (
  353.                             lapstat: LAPStatsPB
  354.                     );
  355.             end;
  356.         IPControlBlockPtr = ^IPControlBlock;
  357.  
  358.     type
  359.         UDPCreatePB = record { for create and release calls }
  360.                 rcvBuff: Ptr;
  361.                 rcvBuffLen: longint;
  362.                 notifyProc: UDPNotifyProc;
  363.                 localport: ipPort;
  364.                 userDataPtr: Ptr;
  365.                 endingPort: ipPort;
  366.             end;
  367.  
  368.     type
  369.         UDPSendPB = record
  370.                 reserved: integer;
  371.                 remoteip: ipAddr;
  372.                 remoteport: ipPort;
  373.                 wds: wdsPtr;
  374.                 checksum: SignedByte;
  375.                 sendLength: integer;
  376.                 userDataPtr: Ptr;
  377.                 localport: ipPort;
  378.             end;
  379.  
  380.     type
  381.         UDPReceivePB = record
  382.                 timeout: integer;
  383.                 remoteip: ipAddr;
  384.                 remoteport: ipPort;
  385.                 rcvBuff: Ptr;
  386.                 rcvBuffLen: integer;
  387.                 secondTimeStamp: integer;
  388.                 userDataPtr: Ptr;
  389.                 destHost: ipAddr;
  390.                 destPort: ipPort;
  391.             end;
  392.  
  393.     type
  394.         UDPMTUPB = record
  395.                 mtuSize: integer;
  396.                 remoteip: ipAddr;
  397.                 userDataPtr: Ptr;
  398.             end;
  399.  
  400.     type
  401.         UDPControlBlock = record
  402.                 qLink: QElemPtr;
  403.                 qType: INTEGER;
  404.                 ioTrap: INTEGER;
  405.                 ioCmdAddr: Ptr;
  406.                 ioCompletion: UDPIOCompletionProc;
  407.                 ioResult: OSErr;
  408.                 ioNamePtr: StringPtr;
  409.                 ioVRefNum: integer;
  410.                 ioCRefNum: integer;
  411.                 csCode: integer;
  412.                 udpStream: StreamPtr;
  413.                 case integer of
  414.                     UDPcsCreate, UDPcsMultiCreate, UDPcsRelease: (
  415.                             create: UDPCreatePB
  416.                     );
  417.                     UDPcsWrite, UDPcsMultiSend: (
  418.                             send: UDPSendPB
  419.                     );
  420.                     UDPcsRead, UDPcsMultiRead: (
  421.                             receive: UDPReceivePB
  422.                     );
  423.                     UDPcsBfrReturn: (
  424.                             return: UDPReceivePB
  425.                     );
  426.                     UDPcsMaxMTUSize: (
  427.                             mtu: UDPMTUPB
  428.                     );
  429.             end;
  430.         UDPControlBlockPtr = ^UDPControlBlock;
  431.  
  432.     const { Validity Flags }
  433.         timeOutValue = $80;
  434.         timeOutAction = $40;
  435.         typeOfService = $20;
  436.         precedence = $10;
  437.  
  438.     const { TOSFlags }
  439.         lowDelay = $01;
  440.         throughPut = $02;
  441.         reliability = $04;
  442.  
  443.     type
  444.         TCPCreatePB = packed record
  445.                 rcvBuff: Ptr;
  446.                 rcvBuffLen: longint;
  447.                 notifyProc: TCPNotifyProc;
  448.                 userDataPtr: Ptr;
  449.             end;
  450.  
  451.         TCPOpenPB = packed record
  452.                 ulpTimeoutValue: Byte;
  453.                 ulpTimeoutAction: SignedByte;
  454.                 validityFlags: Byte;
  455.                 commandTimeoutValue: Byte;
  456.                 remotehost: ipAddr;
  457.                 remoteport: ipPort;
  458.                 localhost: ipAddr;
  459.                 localport: ipPort;
  460.                 tosFlags: Byte;
  461.                 precedence: Byte;
  462.                 dontFrag: C_BOOLEAN;
  463.                 timeToLive: Byte;
  464.                 security: Byte;
  465.                 optionCnt: Byte;
  466.                 options: array[0..39] of Byte;
  467.                 userDataPtr: Ptr;
  468.             end;
  469.  
  470.         TCPSendPB = packed record
  471.                 ulpTimeoutValue: Byte;
  472.                 ulpTimeoutAction: SignedByte;
  473.                 validityFlags: Byte;
  474.                 pushFlag: Byte;
  475.                 urgentFlag: C_BOOLEAN;
  476.                 wds: wdsPtr;
  477.                 sendFree: longint;
  478.                 sendLength: integer;
  479.                 userDataPtr: Ptr;
  480.             end;
  481.  
  482.         TCPReceivePB = packed record
  483.                 commandTimeoutValue: Byte;
  484.                 filler: Byte;
  485.                 markFlag: C_BOOLEAN;
  486.                 urgentFlag: C_BOOLEAN;
  487.                 rcvBuff: Ptr;
  488.                 rcvBuffLength: integer;
  489.                 rdsPtr: Ptr;
  490.                 rdsLength: integer;
  491.                 secondTimeStamp: integer;
  492.                 userDataPtr: Ptr;
  493.             end;
  494.  
  495.         TCPClosePB = packed record
  496.                 ulpTimeoutValue: Byte;
  497.                 ulpTimeoutAction: SignedByte;
  498.                 validityFlags: Byte;
  499.                 userDataPtrX: Ptr;   { Thats mad!  Its not on a word boundary! Parhaps a documentation bug??? }
  500.             end;
  501.  
  502.         HistoBucket = packed record
  503.                 value: integer;
  504.                 counter: longint;
  505.             end;
  506.  
  507.     const
  508.         NumOfHistoBuckets = 7;
  509.  
  510.     type
  511.         TCPConnectionStats = packed record
  512.                 dataPktsRcvd: longint;
  513.                 dataPktsSent: longint;
  514.                 dataPktsResent: longint;
  515.                 bytesRcvd: longint;
  516.                 bytesRcvdDup: longint;
  517.                 bytesRcvdPastWindow: longint;
  518.                 bytesSent: longint;
  519.                 bytesResent: longint;
  520.                 numHistoBuckets: integer;
  521.                 sentSizeHisto: array[1..NumOfHistoBuckets] of HistoBucket;
  522.                 lastRTT: unsignedword;
  523.                 tmrRTT: unsignedword;
  524.                 rttVariance: unsignedword;
  525.                 tmrRTO: unsignedword;
  526.                 sendTries: Byte;
  527.                 sourceQuenchRcvd: Byte;
  528.             end;
  529.         TCPConnectionStatsPtr = ^TCPConnectionStats;
  530.  
  531.         TCPStatusPB = packed record
  532.                 ulpTimeoutValue: Byte;
  533.                 ulpTimeoutAction: SignedByte;
  534.                 unused: longint;
  535.                 remotehost: ipAddr;
  536.                 remoteport: ipPort;
  537.                 localhost: ipAddr;
  538.                 localport: ipPort;
  539.                 tosFlags: Byte;
  540.                 precedence: Byte;
  541.                 connectionState: Byte;
  542.                 filler: Byte;
  543.                 sendWindow: integer;
  544.                 rcvWindow: integer;
  545.                 amtUnackedData: integer;
  546.                 amtUnreadData: integer;
  547.                 securityLevelPtr: Ptr;
  548.                 sendUnacked: longint;
  549.                 sendNext: longint;
  550.                 congestionWindow: longint;
  551.                 rcvNext: longint;
  552.                 srtt: longint;
  553.                 lastRTT: longint;
  554.                 sendMaxSegSize: longint;
  555.                 connStatPtr: TCPConnectionStatsPtr;
  556.                 userDataPtr: Ptr;
  557.             end;
  558.  
  559.         TCPAbortPB = packed record
  560.                 userDataPtr: Ptr;
  561.             end;
  562.  
  563.         TCPParam = packed record
  564.                 tcpRTOA: StringPtr;
  565.                 tcpRTOMin: longint;
  566.                 tcpRTOMax: longint;
  567.                 tcpMaxSegSize: longint;
  568.                 tcpMaxConn: longint;
  569.                 tcpMaxWindow: longint;
  570.             end;
  571.         TCPParamPtr = ^TCPParam;
  572.  
  573.         TCPStats = packed record
  574.                 tcpConnAttempts: longint;
  575.                 tcpConnOpened: longint;
  576.                 tcpConnAccepted: longint;
  577.                 tcpConnClosed: longint;
  578.                 tcpConnAborted: longint;
  579.                 tcpOctetsIn: longint;
  580.                 tcpOctetsOut: longint;
  581.                 tcpOctetsInDup: longint;
  582.                 tcpOctetsRetrans: longint;
  583.                 tcpInputPackets: longint;
  584.                 tcpOutputPkts: longint;
  585.                 tcpDupPkts: longint;
  586.                 tcpRetransPkts: longint;
  587.             end;
  588.         TCPStatsPtr = ^TCPStats;
  589.  
  590.         StreamPtrArray = array[1..1000] of StreamPtr;
  591.         StreamPtrArrayPtr = ^StreamPtrArray;
  592.  
  593.         TCPGlobalInfoPB = packed record
  594.                 tcpParamp: TCPParamPtr;
  595.                 tcpStatsp: TCPStatsPtr;
  596.                 tcpCDBTable: StreamPtrArrayPtr;
  597.                 userDataPtr: Ptr;
  598.                 maxTCPConnections: integer;
  599.             end;
  600.  
  601.         TCPControlBlock = record
  602.                 qLink: QElemPtr;
  603.                 qType: INTEGER;
  604.                 ioTrap: INTEGER;
  605.                 ioCmdAddr: Ptr;
  606.                 ioCompletion: TCPIOCompletionProc; {completion routine, or NIL if none}
  607.                 ioResult: OSErr; {result code}
  608.                 ioNamePtr: StringPtr;
  609.                 ioVRefNum: INTEGER;
  610.                 ioCRefNum: INTEGER; {device refnum}
  611.                 csCode: integer;
  612.                 tcpStream: StreamPtr;
  613.                 case integer of
  614.                     TCPcsCreate: (
  615.                             create: TCPCreatePB
  616.                     );
  617.                     TCPcsActiveOpen, TCPcsPassiveOpen: (
  618.                             open: TCPOpenPB;
  619.                     );
  620.                     TCPcsSend: (
  621.                             send: TCPSendPB;
  622.                     );
  623.                     TCPcsNoCopyRcv, TCPcsRcvBfrReturn, TCPcsRcv: (
  624.                             receive: TCPReceivePB;
  625.                     );
  626.                     TCPcsClose: (
  627.                             close: TCPClosePB;
  628.                     );
  629.                     TCPcsAbort: (
  630.                             abort: TCPAbortPB;
  631.                     );
  632.                     TCPcsStatus: (
  633.                             status: TCPStatusPB;
  634.                     );
  635.                     TCPcsGlobalInfo: (
  636.                             globalInfo: TCPGlobalInfoPB
  637.                     );
  638.             end;
  639.         TCPControlBlockPtr = ^TCPControlBlock;
  640.  
  641. {$ALIGN RESET}
  642. {$POP}
  643.  
  644. implementation
  645.  
  646. end.